package com.example.suhui_test.service;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;

import com.example.suhui_test.ISensorCallback;
import com.example.suhui_test.ISensorService;
import com.example.suhui_test.R;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

// 添加Trace导入
import android.os.Trace;

/**
 * 传感器服务
 * 包装native实现的传感器服务，在单独进程中运行
 */
public class SensorService extends Service {
    private static final String TAG = "SensorService";
    
    // 静态代码块，加载native库
    static {
        try {
            // 添加Trace标记，跟踪native库加载过程
            Trace.beginSection("SensorService_loadNativeLib");
            System.loadLibrary("appsensorservice");
            Log.d(TAG, "成功加载native库: appsensorservice");
            // 结束Trace标记
            Trace.endSection();
        } catch (UnsatisfiedLinkError e) {
            Log.e(TAG, "加载native库失败: " + e.getMessage(), e);
            // 即使发生异常，也要确保结束Trace标记
            Trace.endSection();
        } catch (Exception e) {
            Log.e(TAG, "加载native库时发生异常: " + e.getMessage(), e);
            // 即使发生异常，也要确保结束Trace标记
            Trace.endSection();
        }
    }
    
    // 保存所有注册的回调接口
    private final CopyOnWriteArrayList<ISensorCallback> callbacks = new CopyOnWriteArrayList<>();
    
    // AIDL接口实现
    private final ISensorService.Stub sensorServiceStub = new ISensorService.Stub() {
        @Override
        public void startSensor() throws RemoteException {
            // 修改Trace标记，明确表示服务处理的启动传感器请求
            Trace.beginSection("SensorService_handled_startSensor");
            Log.d(TAG, "启动传感器数据采集");
            nativeStartSensor();
            // 结束Trace标记
            Trace.endSection();
        }
        
        @Override
        public void stopSensor() throws RemoteException {
            // 修改Trace标记，明确表示服务处理的停止传感器请求
            Trace.beginSection("SensorService_handled_stopSensor");
            Log.d(TAG, "停止传感器数据采集");
            nativeStopSensor();
            // 结束Trace标记
            Trace.endSection();
        }
        
        @Override
        public void registerCallback(ISensorCallback callback) throws RemoteException {
            // 修改Trace标记，明确表示服务处理的注册回调请求
            Trace.beginSection("SensorService_handled_registerCallback");
            if (callback != null && !callbacks.contains(callback)) {
                Log.d(TAG, "注册传感器回调");
                callbacks.add(callback);
            }
            // 结束Trace标记
            Trace.endSection();
        }
        
        @Override
        public void unregisterCallback(ISensorCallback callback) throws RemoteException {
            // 修改Trace标记，明确表示服务处理的注销回调请求
            Trace.beginSection("SensorService_handled_unregisterCallback");
            if (callback != null) {
                Log.d(TAG, "注销传感器回调");
                callbacks.remove(callback);
            }
            // 结束Trace标记
            Trace.endSection();
        }
        
        @Override
        public boolean isSensorRunning() throws RemoteException {
            // 修改Trace标记，明确表示服务处理的查询传感器状态请求
            Trace.beginSection("SensorService_handled_isSensorRunning");
            boolean result = nativeIsSensorRunning();
            Log.d(TAG, "查询传感器运行状态: " + result);
            // 结束Trace标记
            Trace.endSection();
            return result;
        }
    };
    
    // 向所有注册的客户端发送传感器数据
    public void notifySensorData(float x, float y, float z) {
        // 修改Trace标记，明确表示服务内部的通知数据方法
        Trace.beginSection("SensorService_internal_notifySensorData");
        Log.d(TAG, "通知传感器数据: x=" + x + ", y=" + y + ", z=" + z);
        for (ISensorCallback callback : callbacks) {
            try {
                callback.onSensorDataReceived(x, y, z);
            } catch (RemoteException e) {
                Log.e(TAG, "发送传感器数据失败", e);
                callbacks.remove(callback);
            }
        }
        // 结束Trace标记
        Trace.endSection();
    }
    
    // 向所有注册的客户端发送状态变化通知
    public void notifySensorStatus(boolean isRunning) {
        // 修改Trace标记，明确表示服务内部的通知状态方法
        Trace.beginSection("SensorService_internal_notifySensorStatus");
        Log.d(TAG, "通知传感器状态: " + (isRunning ? "运行中" : "已停止"));
        for (ISensorCallback callback : callbacks) {
            try {
                callback.onSensorStatusChanged(isRunning);
            } catch (RemoteException e) {
                Log.e(TAG, "发送传感器状态失败", e);
                callbacks.remove(callback);
            }
        }
        // 结束Trace标记
        Trace.endSection();
    }
    
    // 在onCreate方法中添加Trace
    @Override
    public void onCreate() {
        super.onCreate();
        // 修改Trace标记，明确表示服务生命周期事件
        Trace.beginSection("SensorService_lifecycle_onCreate");
        Log.d(TAG, "SensorService创建，进程ID: " + android.os.Process.myPid());
        Log.d(TAG, "Service creation stack trace:", new Throwable("Service creation trace"));
        
        // 初始化native服务
        nativeInit();
        
        // 结束Trace标记
        Trace.endSection();
    }
    
    // 在onBind方法中添加Trace
    @Override
    public IBinder onBind(Intent intent) {
        // 修改Trace标记，明确表示服务处理的绑定请求
        Trace.beginSection("SensorService_handled_onBind");
        Log.d(TAG, "绑定传感器服务，Intent: " + intent);
        Log.d(TAG, "Binding component: " + intent.getComponent());
        Log.d(TAG, "Binding Action: " + intent.getAction());
        Log.d(TAG, "Service binding stack trace:", new Throwable("Service binding trace"));
        
        IBinder result = sensorServiceStub;
        
        // 结束Trace标记
        Trace.endSection();
        return result;
    }
    
    // 在onDestroy方法中添加Trace
    @Override
    public void onDestroy() {
        // 修改Trace标记，明确表示服务生命周期事件
        Trace.beginSection("SensorService_lifecycle_onDestroy");
        Log.d(TAG, "SensorService销毁开始");
        Log.d(TAG, "Service destruction stack trace:", new Throwable("Service destruction trace"));
        
        // 释放native资源
        nativeRelease();
        callbacks.clear();
        
        super.onDestroy();
        Log.d(TAG, "SensorService销毁完成");
        
        // 结束Trace标记
        Trace.endSection();
    }
    
    // Native方法声明
    private native void nativeInit();
    private native void nativeRelease();
    private native void nativeStartSensor();
    private native void nativeStopSensor();
    private native boolean nativeIsSensorRunning();
}